// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.supplier.flow.form.relation;

import com.fowo.api.common.annotaion.DataObjectType;
import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import com.fowo.api.entity.SupplierFlowFormRelation;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@DataObjectType(SupplierFlowFormRelation.class)
@Setter
@Getter
public class SupplierFlowFormRelationSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "SupplierFlowFormRelation".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("flowNodeId", "sfn");
    map.put("startUser", "su");
    map.put("doUser", "su2");
    map.put("toUser", "su3");
    map.put("forwardUser", "su4");
    map.put("operatorUser", "su5");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：SupplierFlowFormRelation/All, SupplierFlowFormRelation/Pending, SupplierFlowFormRelation/Processing, SupplierFlowFormRelation/AboutMe, SupplierFlowFormRelation/Start, SupplierFlowFormRelation/ForwardMe
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 标题(模糊搜索)
   */
  private String title;

  /**
   * 标题 比较(eq)
   */
  private String titleEq;
  /**
   * 标题 比较(neq)
   */
  private String titleNeq;
  /**
   * 标题 比较(gt)
   */
  private String titleGt;
  /**
   * 标题 比较(gte)
   */
  private String titleGte;
  /**
   * 标题 比较(lt)
   */
  private String titleLt;
  /**
   * 标题 比较(lte)
   */
  private String titleLte;
  /**
   * 标题 比较(contains)
   */
  private String titleContains;
  /**
   * 标题 比较(notcontains)
   */
  private String titleNotcontains;
  /**
   * 标题 比较(startswith)
   */
  private String titleStartswith;
  /**
   * 标题 比较(endswith)
   */
  private String titleEndswith;
  /**
   * 标题 比较(isnull)
   */
  private Boolean titleIsnull;
  /**
   * 标题 比较(isnotnull)
   */
  private Boolean titleIsnotnull;

  /**
   * 标题(精确搜索)
   */
  private List<String> titleInList;

  /**
   * 编号(模糊搜索)
   */
  private String code;

  /**
   * 编号 比较(eq)
   */
  private String codeEq;
  /**
   * 编号 比较(neq)
   */
  private String codeNeq;
  /**
   * 编号 比较(gt)
   */
  private String codeGt;
  /**
   * 编号 比较(gte)
   */
  private String codeGte;
  /**
   * 编号 比较(lt)
   */
  private String codeLt;
  /**
   * 编号 比较(lte)
   */
  private String codeLte;
  /**
   * 编号 比较(contains)
   */
  private String codeContains;
  /**
   * 编号 比较(notcontains)
   */
  private String codeNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private String codeStartswith;
  /**
   * 编号 比较(endswith)
   */
  private String codeEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean codeIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean codeIsnotnull;

  /**
   * 编号(精确搜索)
   */
  private List<String> codeInList;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 任务编码
   */
  private String enCode;

  /**
   * 任务编码 比较(eq)
   */
  private String enCodeEq;
  /**
   * 任务编码 比较(neq)
   */
  private String enCodeNeq;
  /**
   * 任务编码 比较(gt)
   */
  private String enCodeGt;
  /**
   * 任务编码 比较(gte)
   */
  private String enCodeGte;
  /**
   * 任务编码 比较(lt)
   */
  private String enCodeLt;
  /**
   * 任务编码 比较(lte)
   */
  private String enCodeLte;
  /**
   * 任务编码 比较(contains)
   */
  private String enCodeContains;
  /**
   * 任务编码 比较(notcontains)
   */
  private String enCodeNotcontains;
  /**
   * 任务编码 比较(startswith)
   */
  private String enCodeStartswith;
  /**
   * 任务编码 比较(endswith)
   */
  private String enCodeEndswith;
  /**
   * 任务编码 比较(isnull)
   */
  private Boolean enCodeIsnull;
  /**
   * 任务编码 比较(isnotnull)
   */
  private Boolean enCodeIsnotnull;

  /**
   * 任务编码(精确搜索)
   */
  private List<String> enCodeInList;

  /**
   * 流程节点
   */
  private Long flowNodeId;

  /**
   * 流程节点 比较(eq)
   */
  private Long flowNodeIdEq;
  /**
   * 流程节点 比较(neq)
   */
  private Long flowNodeIdNeq;
  /**
   * 流程节点 比较(gt)
   */
  private Long flowNodeIdGt;
  /**
   * 流程节点 比较(gte)
   */
  private Long flowNodeIdGte;
  /**
   * 流程节点 比较(lt)
   */
  private Long flowNodeIdLt;
  /**
   * 流程节点 比较(lte)
   */
  private Long flowNodeIdLte;
  /**
   * 流程节点 比较(contains)
   */
  private Long flowNodeIdContains;
  /**
   * 流程节点 比较(notcontains)
   */
  private Long flowNodeIdNotcontains;
  /**
   * 流程节点 比较(startswith)
   */
  private Long flowNodeIdStartswith;
  /**
   * 流程节点 比较(endswith)
   */
  private Long flowNodeIdEndswith;
  /**
   * 流程节点 比较(isnull)
   */
  private Boolean flowNodeIdIsnull;
  /**
   * 流程节点 比较(isnotnull)
   */
  private Boolean flowNodeIdIsnotnull;
  /**
   * 流程节点的流程编码 比较(eq)
   */
  private String flowNodeIdEnCodeEq;
  /**
   * 流程节点的流程编码 比较(neq)
   */
  private String flowNodeIdEnCodeNeq;
  /**
   * 流程节点的流程编码 比较(gt)
   */
  private String flowNodeIdEnCodeGt;
  /**
   * 流程节点的流程编码 比较(gte)
   */
  private String flowNodeIdEnCodeGte;
  /**
   * 流程节点的流程编码 比较(lt)
   */
  private String flowNodeIdEnCodeLt;
  /**
   * 流程节点的流程编码 比较(lte)
   */
  private String flowNodeIdEnCodeLte;
  /**
   * 流程节点的流程编码 比较(contains)
   */
  private String flowNodeIdEnCodeContains;
  /**
   * 流程节点的流程编码 比较(notcontains)
   */
  private String flowNodeIdEnCodeNotcontains;
  /**
   * 流程节点的流程编码 比较(startswith)
   */
  private String flowNodeIdEnCodeStartswith;
  /**
   * 流程节点的流程编码 比较(endswith)
   */
  private String flowNodeIdEnCodeEndswith;
  /**
   * 流程节点的流程编码 比较(isnull)
   */
  private Boolean flowNodeIdEnCodeIsnull;
  /**
   * 流程节点的流程编码 比较(isnotnull)
   */
  private Boolean flowNodeIdEnCodeIsnotnull;

  /**
   * 流程节点(范围搜索)
   */
  private List<Long> flowNodeIdInList;

  /**
   * 表单id
   */
  private Long formId;

  /**
   * 最小表单id
   */
  private Long formIdMin;

  /**
   * 最大表单id
   */
  private Long formIdMax;

  /**
   * 表单id 比较(eq)
   */
  private Long formIdEq;
  /**
   * 表单id 比较(neq)
   */
  private Long formIdNeq;
  /**
   * 表单id 比较(gt)
   */
  private Long formIdGt;
  /**
   * 表单id 比较(gte)
   */
  private Long formIdGte;
  /**
   * 表单id 比较(lt)
   */
  private Long formIdLt;
  /**
   * 表单id 比较(lte)
   */
  private Long formIdLte;
  /**
   * 表单id 比较(contains)
   */
  private Long formIdContains;
  /**
   * 表单id 比较(notcontains)
   */
  private Long formIdNotcontains;
  /**
   * 表单id 比较(startswith)
   */
  private Long formIdStartswith;
  /**
   * 表单id 比较(endswith)
   */
  private Long formIdEndswith;
  /**
   * 表单id 比较(isnull)
   */
  private Boolean formIdIsnull;
  /**
   * 表单id 比较(isnotnull)
   */
  private Boolean formIdIsnotnull;

  /**
   * 表单状态
   */
  private String formStatus;

  /**
   * 表单状态 比较(eq)
   */
  private String formStatusEq;
  /**
   * 表单状态 比较(neq)
   */
  private String formStatusNeq;
  /**
   * 表单状态 比较(gt)
   */
  private String formStatusGt;
  /**
   * 表单状态 比较(gte)
   */
  private String formStatusGte;
  /**
   * 表单状态 比较(lt)
   */
  private String formStatusLt;
  /**
   * 表单状态 比较(lte)
   */
  private String formStatusLte;
  /**
   * 表单状态 比较(contains)
   */
  private String formStatusContains;
  /**
   * 表单状态 比较(notcontains)
   */
  private String formStatusNotcontains;
  /**
   * 表单状态 比较(startswith)
   */
  private String formStatusStartswith;
  /**
   * 表单状态 比较(endswith)
   */
  private String formStatusEndswith;
  /**
   * 表单状态 比较(isnull)
   */
  private Boolean formStatusIsnull;
  /**
   * 表单状态 比较(isnotnull)
   */
  private Boolean formStatusIsnotnull;

  /**
   * 表单状态(精确搜索)
   */
  private List<String> formStatusInList;

  /**
   * 发起人
   */
  private Long startUser;

  /**
   * 发起人 比较(eq)
   */
  private Long startUserEq;
  /**
   * 发起人 比较(neq)
   */
  private Long startUserNeq;
  /**
   * 发起人 比较(gt)
   */
  private Long startUserGt;
  /**
   * 发起人 比较(gte)
   */
  private Long startUserGte;
  /**
   * 发起人 比较(lt)
   */
  private Long startUserLt;
  /**
   * 发起人 比较(lte)
   */
  private Long startUserLte;
  /**
   * 发起人 比较(contains)
   */
  private Long startUserContains;
  /**
   * 发起人 比较(notcontains)
   */
  private Long startUserNotcontains;
  /**
   * 发起人 比较(startswith)
   */
  private Long startUserStartswith;
  /**
   * 发起人 比较(endswith)
   */
  private Long startUserEndswith;
  /**
   * 发起人 比较(isnull)
   */
  private Boolean startUserIsnull;
  /**
   * 发起人 比较(isnotnull)
   */
  private Boolean startUserIsnotnull;
  /**
   * 发起人的显示用户名 比较(eq)
   */
  private String startUserNameEq;
  /**
   * 发起人的显示用户名 比较(neq)
   */
  private String startUserNameNeq;
  /**
   * 发起人的显示用户名 比较(gt)
   */
  private String startUserNameGt;
  /**
   * 发起人的显示用户名 比较(gte)
   */
  private String startUserNameGte;
  /**
   * 发起人的显示用户名 比较(lt)
   */
  private String startUserNameLt;
  /**
   * 发起人的显示用户名 比较(lte)
   */
  private String startUserNameLte;
  /**
   * 发起人的显示用户名 比较(contains)
   */
  private String startUserNameContains;
  /**
   * 发起人的显示用户名 比较(notcontains)
   */
  private String startUserNameNotcontains;
  /**
   * 发起人的显示用户名 比较(startswith)
   */
  private String startUserNameStartswith;
  /**
   * 发起人的显示用户名 比较(endswith)
   */
  private String startUserNameEndswith;
  /**
   * 发起人的显示用户名 比较(isnull)
   */
  private Boolean startUserNameIsnull;
  /**
   * 发起人的显示用户名 比较(isnotnull)
   */
  private Boolean startUserNameIsnotnull;

  /**
   * 发起人(范围搜索)
   */
  private List<Long> startUserInList;

  /**
   * 执行人
   */
  private Long doUser;

  /**
   * 执行人 比较(eq)
   */
  private Long doUserEq;
  /**
   * 执行人 比较(neq)
   */
  private Long doUserNeq;
  /**
   * 执行人 比较(gt)
   */
  private Long doUserGt;
  /**
   * 执行人 比较(gte)
   */
  private Long doUserGte;
  /**
   * 执行人 比较(lt)
   */
  private Long doUserLt;
  /**
   * 执行人 比较(lte)
   */
  private Long doUserLte;
  /**
   * 执行人 比较(contains)
   */
  private Long doUserContains;
  /**
   * 执行人 比较(notcontains)
   */
  private Long doUserNotcontains;
  /**
   * 执行人 比较(startswith)
   */
  private Long doUserStartswith;
  /**
   * 执行人 比较(endswith)
   */
  private Long doUserEndswith;
  /**
   * 执行人 比较(isnull)
   */
  private Boolean doUserIsnull;
  /**
   * 执行人 比较(isnotnull)
   */
  private Boolean doUserIsnotnull;
  /**
   * 执行人的显示用户名 比较(eq)
   */
  private String doUserNameEq;
  /**
   * 执行人的显示用户名 比较(neq)
   */
  private String doUserNameNeq;
  /**
   * 执行人的显示用户名 比较(gt)
   */
  private String doUserNameGt;
  /**
   * 执行人的显示用户名 比较(gte)
   */
  private String doUserNameGte;
  /**
   * 执行人的显示用户名 比较(lt)
   */
  private String doUserNameLt;
  /**
   * 执行人的显示用户名 比较(lte)
   */
  private String doUserNameLte;
  /**
   * 执行人的显示用户名 比较(contains)
   */
  private String doUserNameContains;
  /**
   * 执行人的显示用户名 比较(notcontains)
   */
  private String doUserNameNotcontains;
  /**
   * 执行人的显示用户名 比较(startswith)
   */
  private String doUserNameStartswith;
  /**
   * 执行人的显示用户名 比较(endswith)
   */
  private String doUserNameEndswith;
  /**
   * 执行人的显示用户名 比较(isnull)
   */
  private Boolean doUserNameIsnull;
  /**
   * 执行人的显示用户名 比较(isnotnull)
   */
  private Boolean doUserNameIsnotnull;

  /**
   * 执行人(范围搜索)
   */
  private List<Long> doUserInList;

  /**
   * 拾取人
   */
  private Long toUser;

  /**
   * 拾取人 比较(eq)
   */
  private Long toUserEq;
  /**
   * 拾取人 比较(neq)
   */
  private Long toUserNeq;
  /**
   * 拾取人 比较(gt)
   */
  private Long toUserGt;
  /**
   * 拾取人 比较(gte)
   */
  private Long toUserGte;
  /**
   * 拾取人 比较(lt)
   */
  private Long toUserLt;
  /**
   * 拾取人 比较(lte)
   */
  private Long toUserLte;
  /**
   * 拾取人 比较(contains)
   */
  private Long toUserContains;
  /**
   * 拾取人 比较(notcontains)
   */
  private Long toUserNotcontains;
  /**
   * 拾取人 比较(startswith)
   */
  private Long toUserStartswith;
  /**
   * 拾取人 比较(endswith)
   */
  private Long toUserEndswith;
  /**
   * 拾取人 比较(isnull)
   */
  private Boolean toUserIsnull;
  /**
   * 拾取人 比较(isnotnull)
   */
  private Boolean toUserIsnotnull;
  /**
   * 拾取人的显示用户名 比较(eq)
   */
  private String toUserNameEq;
  /**
   * 拾取人的显示用户名 比较(neq)
   */
  private String toUserNameNeq;
  /**
   * 拾取人的显示用户名 比较(gt)
   */
  private String toUserNameGt;
  /**
   * 拾取人的显示用户名 比较(gte)
   */
  private String toUserNameGte;
  /**
   * 拾取人的显示用户名 比较(lt)
   */
  private String toUserNameLt;
  /**
   * 拾取人的显示用户名 比较(lte)
   */
  private String toUserNameLte;
  /**
   * 拾取人的显示用户名 比较(contains)
   */
  private String toUserNameContains;
  /**
   * 拾取人的显示用户名 比较(notcontains)
   */
  private String toUserNameNotcontains;
  /**
   * 拾取人的显示用户名 比较(startswith)
   */
  private String toUserNameStartswith;
  /**
   * 拾取人的显示用户名 比较(endswith)
   */
  private String toUserNameEndswith;
  /**
   * 拾取人的显示用户名 比较(isnull)
   */
  private Boolean toUserNameIsnull;
  /**
   * 拾取人的显示用户名 比较(isnotnull)
   */
  private Boolean toUserNameIsnotnull;

  /**
   * 拾取人(范围搜索)
   */
  private List<Long> toUserInList;

  /**
   * 转发人
   */
  private Long forwardUser;

  /**
   * 转发人 比较(eq)
   */
  private Long forwardUserEq;
  /**
   * 转发人 比较(neq)
   */
  private Long forwardUserNeq;
  /**
   * 转发人 比较(gt)
   */
  private Long forwardUserGt;
  /**
   * 转发人 比较(gte)
   */
  private Long forwardUserGte;
  /**
   * 转发人 比较(lt)
   */
  private Long forwardUserLt;
  /**
   * 转发人 比较(lte)
   */
  private Long forwardUserLte;
  /**
   * 转发人 比较(contains)
   */
  private Long forwardUserContains;
  /**
   * 转发人 比较(notcontains)
   */
  private Long forwardUserNotcontains;
  /**
   * 转发人 比较(startswith)
   */
  private Long forwardUserStartswith;
  /**
   * 转发人 比较(endswith)
   */
  private Long forwardUserEndswith;
  /**
   * 转发人 比较(isnull)
   */
  private Boolean forwardUserIsnull;
  /**
   * 转发人 比较(isnotnull)
   */
  private Boolean forwardUserIsnotnull;
  /**
   * 转发人的显示用户名 比较(eq)
   */
  private String forwardUserNameEq;
  /**
   * 转发人的显示用户名 比较(neq)
   */
  private String forwardUserNameNeq;
  /**
   * 转发人的显示用户名 比较(gt)
   */
  private String forwardUserNameGt;
  /**
   * 转发人的显示用户名 比较(gte)
   */
  private String forwardUserNameGte;
  /**
   * 转发人的显示用户名 比较(lt)
   */
  private String forwardUserNameLt;
  /**
   * 转发人的显示用户名 比较(lte)
   */
  private String forwardUserNameLte;
  /**
   * 转发人的显示用户名 比较(contains)
   */
  private String forwardUserNameContains;
  /**
   * 转发人的显示用户名 比较(notcontains)
   */
  private String forwardUserNameNotcontains;
  /**
   * 转发人的显示用户名 比较(startswith)
   */
  private String forwardUserNameStartswith;
  /**
   * 转发人的显示用户名 比较(endswith)
   */
  private String forwardUserNameEndswith;
  /**
   * 转发人的显示用户名 比较(isnull)
   */
  private Boolean forwardUserNameIsnull;
  /**
   * 转发人的显示用户名 比较(isnotnull)
   */
  private Boolean forwardUserNameIsnotnull;

  /**
   * 转发人(范围搜索)
   */
  private List<Long> forwardUserInList;

  /**
   * 经办人
   */
  private Long operatorUser;

  /**
   * 经办人 比较(eq)
   */
  private Long operatorUserEq;
  /**
   * 经办人 比较(neq)
   */
  private Long operatorUserNeq;
  /**
   * 经办人 比较(gt)
   */
  private Long operatorUserGt;
  /**
   * 经办人 比较(gte)
   */
  private Long operatorUserGte;
  /**
   * 经办人 比较(lt)
   */
  private Long operatorUserLt;
  /**
   * 经办人 比较(lte)
   */
  private Long operatorUserLte;
  /**
   * 经办人 比较(contains)
   */
  private Long operatorUserContains;
  /**
   * 经办人 比较(notcontains)
   */
  private Long operatorUserNotcontains;
  /**
   * 经办人 比较(startswith)
   */
  private Long operatorUserStartswith;
  /**
   * 经办人 比较(endswith)
   */
  private Long operatorUserEndswith;
  /**
   * 经办人 比较(isnull)
   */
  private Boolean operatorUserIsnull;
  /**
   * 经办人 比较(isnotnull)
   */
  private Boolean operatorUserIsnotnull;
  /**
   * 经办人的显示用户名 比较(eq)
   */
  private String operatorUserNameEq;
  /**
   * 经办人的显示用户名 比较(neq)
   */
  private String operatorUserNameNeq;
  /**
   * 经办人的显示用户名 比较(gt)
   */
  private String operatorUserNameGt;
  /**
   * 经办人的显示用户名 比较(gte)
   */
  private String operatorUserNameGte;
  /**
   * 经办人的显示用户名 比较(lt)
   */
  private String operatorUserNameLt;
  /**
   * 经办人的显示用户名 比较(lte)
   */
  private String operatorUserNameLte;
  /**
   * 经办人的显示用户名 比较(contains)
   */
  private String operatorUserNameContains;
  /**
   * 经办人的显示用户名 比较(notcontains)
   */
  private String operatorUserNameNotcontains;
  /**
   * 经办人的显示用户名 比较(startswith)
   */
  private String operatorUserNameStartswith;
  /**
   * 经办人的显示用户名 比较(endswith)
   */
  private String operatorUserNameEndswith;
  /**
   * 经办人的显示用户名 比较(isnull)
   */
  private Boolean operatorUserNameIsnull;
  /**
   * 经办人的显示用户名 比较(isnotnull)
   */
  private Boolean operatorUserNameIsnotnull;

  /**
   * 经办人(范围搜索)
   */
  private List<Long> operatorUserInList;

  /**
   * 最早截止时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date endTimeStart;

  /**
   * 最晚截止时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date endTimeEnd;

  /**
   * 截止时间 比较(eq)
   */
  private Date endTimeEq;
  /**
   * 截止时间 比较(neq)
   */
  private Date endTimeNeq;
  /**
   * 截止时间 比较(gt)
   */
  private Date endTimeGt;
  /**
   * 截止时间 比较(gte)
   */
  private Date endTimeGte;
  /**
   * 截止时间 比较(lt)
   */
  private Date endTimeLt;
  /**
   * 截止时间 比较(lte)
   */
  private Date endTimeLte;
  /**
   * 截止时间 比较(contains)
   */
  private Date endTimeContains;
  /**
   * 截止时间 比较(notcontains)
   */
  private Date endTimeNotcontains;
  /**
   * 截止时间 比较(startswith)
   */
  private Date endTimeStartswith;
  /**
   * 截止时间 比较(endswith)
   */
  private Date endTimeEndswith;
  /**
   * 截止时间 比较(isnull)
   */
  private Boolean endTimeIsnull;
  /**
   * 截止时间 比较(isnotnull)
   */
  private Boolean endTimeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
